home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 1 / BBS in a box - Trilogy I.iso / Files / Publish / J-L / lpr / lpr source / printit.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-18  |  11.1 KB  |  427 lines  |  [TEXT/MPS ]

  1. #if !defined(USEDUMP)
  2.     #include "lprlib.h"
  3.     #include "lprdef.h"
  4.     #include "lprfuncs.h"
  5. #else
  6.     #pragma load "lprDumpFile"
  7. #endif
  8.  
  9. unsigned char prtstate;        /* print processing state */
  10. unsigned long prtstime;        /* time prtstate last changed */
  11. unsigned char filename[30];    /* filename for server to use */
  12. unsigned char sbuf[512];    /* tcp send buffer */
  13. short sbuflen;                /* size of send buffer */
  14. unsigned char cmds[1024];    /* control data buffer */
  15. unsigned char prtfname[128];  /* name of file to print */
  16. extern unsigned char pend_conn();    /* connection status */
  17. extern unsigned char myipnum[4];    /* my IP number */
  18.  
  19. static unsigned char prtmsg[128];    /* debug message buffer */
  20. unsigned long filesize;        /* total number of data bytes we send */
  21. short vnum;                    /* volume number for file I/O */
  22. unsigned char * filelist;    /* pointer to list of files to process */
  23. unsigned char countonly;    /* flag to only count output */
  24. short prtfcount;            /* count of files printed */
  25.  
  26. extern unsigned long * Ticks;
  27. extern settings_list cs, ds;
  28. extern unsigned char setmsg1[];    
  29. extern unsigned char setmsg2[];    
  30. extern unsigned char vmpass[];        /* VM password */
  31. extern unsigned long passtime;        /* time password last stored */
  32. extern struct Point sfgpoint;        /* standard get file dialog location */
  33. extern unsigned char printlist;        /* TRUE if list to be printed */
  34. extern DialogPtr statptr;
  35. extern unsigned char prtstat[];
  36.  
  37. void printit(void)
  38. {
  39. Point where;
  40. FileFilterProcPtr fileFilter;
  41. DlgHookProcPtr dlgHook;
  42. short numTypes;
  43. SFTypeList typeList;
  44. SFReply reply;
  45. pascal Boolean (*filterProc)();
  46.  
  47. OSErr rc;
  48. unsigned long listsize, readcount;
  49. short fnum;
  50.  
  51. /* for VM printers, get a valid password */
  52. if (cs.vmflag) {
  53.     if (((*Ticks) - passtime) > PASSLIMIT)
  54.         memset(vmpass, 0, 9);
  55.     if ((vmpass[0] == 0) || (cs.vmuser[0] == 0))
  56.         destdlg(1);        /* ensure we get all three or none */
  57.                         /* unless user selected "cancel" */
  58.     if (cs.vmflag) {
  59.         if ((vmpass[0] == 0) || (cs.vmuser[0] == 0))
  60.             return;
  61.         }
  62.     }
  63.  
  64. /* get input file from user */
  65.  
  66. where = sfgpoint;
  67. fileFilter = 0;
  68. dlgHook = 0;
  69. numTypes = 1;
  70. typeList[0] = 'TEXT';
  71. dlgHook = 0;
  72. filterProc = SF_Filter;
  73. if (filelist) 
  74.     SFPGetFile(where, "\pSelect list of files:", fileFilter,
  75.                  numTypes, typeList, dlgHook, &reply, getDlgID, 
  76.                 (ModalFilterProcPtr)filterProc);
  77. else
  78.     SFPGetFile(where, "\pSelect file to be printed:", fileFilter,
  79.                  numTypes, typeList, dlgHook, &reply, getDlgID, 
  80.                 (ModalFilterProcPtr)filterProc);
  81. if (reply.good == 0) return;
  82. p2cstr(&reply.fName);                    /* save filename */
  83. strcpy(prtfname, &reply.fName);
  84. c2pstr(&reply.fName);
  85. vnum = reply.vRefNum;                /* save volume reference */
  86. if (statptr) {                    /* restore status in case covered */
  87.     DrawDialog(statptr);
  88.     statGrowIcon();
  89.     }
  90.  
  91. /* set filelist to point to list of files to print */
  92. if (printlist) {
  93.                     /* prepare first part of error messages */
  94.     sprintf(setmsg1, "Error reading file \"%s\"", prtfname);
  95.     rc = fsrdopen(prtfname, vnum, &fnum);
  96.     if (rc != 0) {
  97.         sprintf(setmsg2, "Error %d opening file", rc);
  98.         seterr();
  99.         return;
  100.         }
  101.     rc = GetEOF(fnum, (long *)&listsize);    /* get file size */
  102.     if (rc != 0) {
  103.         FSClose(fnum);
  104.         sprintf(setmsg2, "Error %d getting file size", rc);
  105.         seterr();
  106.         return;
  107.         }
  108.     filelist = (unsigned char *)NewPtr(listsize+2);    /* allocate buffer */
  109.                                 /* extra bytes for null and new line */
  110.     if (filelist == 0L) {
  111.         FSClose(fnum);
  112.         sprintf(setmsg2, "Not enough storage (%ld bytes) for list file", listsize);
  113.         seterr();
  114.         return;
  115.         }
  116.     readcount = listsize;            /* read file data */
  117.     rc = FSRead(fnum, (long *)&readcount, filelist);
  118.     FSClose(fnum);                    /* close file */
  119.     if ((rc != 0) || (readcount != listsize)) {
  120.         DisposPtr(filelist);
  121.         filelist = 0;
  122.         if (rc == 0) rc = 4;
  123.         sprintf(setmsg2, "Error %d reading file contents", rc);
  124.         seterr();
  125.         return;
  126.         }
  127.     }
  128. else {            /* single file */
  129.     listsize = strlen(prtfname);
  130.     filelist = (unsigned char *)NewPtr(listsize+2);    /* allocate buffer */
  131.                                 /* extra bytes for null and new line */
  132.     if (filelist == 0L) {
  133.         stgalert("print file name", "NewPtr", listsize+2);
  134.         return;
  135.         }
  136.     strcpy(filelist, prtfname);
  137.     }
  138.  
  139. filelist[listsize] = 0;            /* terminate list */
  140.                             /* make sure last character is CR */
  141. if (filelist[listsize-1] != 0x0d) strcat(filelist, "\015");
  142.  
  143. /* get number of bytes we will send for file data */
  144. countonly = 1;        /* call formatter for counting only */
  145. prtfcount = 0;        /* reset file count */
  146. rc = prtformat();
  147.                     /* sets "filesize" if rc = 0 */
  148. if (rc != 0) {
  149.     sprintf(setmsg2, "Error %d calculating file size", rc);
  150.     seterr();
  151.     prtclean();
  152.     return;
  153.     }
  154. countonly = 0;        /* really send next time */
  155. sprintf(prtstat, "Ready to send %ld bytes", filesize);
  156. statdlg(0, 0x04);
  157.  
  158. /* attempt to open connection to lpd */
  159. prtstate = 0;
  160. prtstime = (*Ticks);
  161. watchcurs();
  162. tcplgin();
  163. }
  164.  
  165. void prtevent(s, len)
  166. unsigned char * s;
  167. short len;
  168. {
  169. OSErr rc;
  170.  
  171. sprintf(prtmsg, "print event at state %d", prtstate);
  172. putln(prtmsg);
  173.  
  174. switch(prtstate) {
  175.     case 0:                /* waiting for open */
  176.         if (s != 0) return;
  177.         sprintf(prtstat, "Sending printer name");
  178.         statdlg(0, 0x04);
  179.         prtstate = 1;
  180.         prtstime = (*Ticks);
  181.         sprintf(sbuf, "\2%s\r", cs.printer);
  182.         tcpwrite(sbuf, strlen(sbuf));
  183.         break;
  184.     case 1:                /* waiting for printer name response */
  185.         tcpdump("name response", s, len);
  186.         if ((s[0] != '\0') || (len != 1)) {
  187.             tcplgout();
  188.             server_err(s, len, 1, 0, 0);
  189.             return;
  190.             }
  191.         sprintf(prtstat, "Sending file information");
  192.         statdlg(0, 0x04);
  193.         prtstate = 2;
  194.         prtstime = (*Ticks);
  195.         sendfinfo();    /* send file info */
  196.         break;
  197.     case 2:                /* waiting for file info. response */
  198.         tcpdump("info response", s, len);
  199.         if (s[0] == '\2') {
  200.             tcplgout();
  201.             stoperr(sizalrt);
  202.             return;
  203.             }
  204.         else if ((s[0] != '\0') || (len != 1)) {
  205.             tcplgout();
  206.             server_err(s, len, 0, 0, 0);
  207.             return;
  208.             }
  209.         prtstate = 3;
  210.         prtstime = (*Ticks);
  211.         prtfcount = 0;        /* reset file count */
  212.         rc = prtformat();    /* send file data */
  213.         if (rc != 0) {
  214.             tcplgout();
  215.             return;
  216.             }
  217.         break;
  218.     case 3:
  219.         tcpdump("data response", s, len);
  220.         if ((s[0] != '\0') || (len != 1)) {
  221.             tcplgout();
  222.             server_err(s, len, 0, 0, 1);
  223.             return;
  224.             }
  225.         sprintf(prtstat, "Sending control information");
  226.         statdlg(0, 0x04);
  227.         prtstate = 4;
  228.         prtstime = (*Ticks);
  229.         sendctlinfo();    /* send control info */
  230.         break;
  231.     case 4:
  232.         tcpdump("ctlinfo response", s, len);
  233.         if (s[0] == '\2') {
  234.             tcplgout();
  235.             stoperr(sizalrt);
  236.             return;
  237.             }
  238.         else if ((s[0] != '\0') || (len != 1)) {
  239.             tcplgout();
  240.             server_err(s, len, 0, 1, 0);
  241.             return;
  242.             }
  243.         sprintf(prtstat, "Sending control file");
  244.         statdlg(0, 0x04);
  245.         prtstate = 5;
  246.         prtstime = (*Ticks);
  247.         sendcontrol();    /* send control data */
  248.         break;
  249.     case 5:
  250.         tcpdump("control data response", s, len);
  251.         if ((s[0] != '\0') || (len != 1)) {
  252.             tcplgout();
  253.             server_err(s, len, 0, 1, 1);
  254.             return;
  255.             }
  256.         tcplgout();            /* resets prtstate, prtstime */
  257.         if (printlist) {
  258.             sprintf(setmsg1, "List \"%s\" (%d files) sent successfully to %s at %s",
  259.                 prtfname, prtfcount, cs.printer, cs.hostname);
  260.             }
  261.         else {
  262.             sprintf(setmsg1, "File \"%s\" sent successfully to %s at %s",
  263.                 prtfname, cs.printer, cs.hostname);
  264.             }
  265.         if (cs.vmflag) sprintf(setmsg2, "Printed for VM userid %s", cs.vmuser);
  266.         else sprintf(setmsg2, "Printed for user %s", cs.orguser);
  267.         okalrt();
  268.         break;
  269.     default:
  270.         break;
  271.     }
  272. }
  273.  
  274. void sendfinfo(void)
  275. {
  276. static unsigned long * Time = 0x20C;
  277. unsigned long currtime;
  278. short filetime;
  279.  
  280. /* compute filename to use, except for first letter */
  281. currtime = *Time;        /* wait for time to change */
  282. while (currtime == *Time) /*Stask()*/;
  283. filetime = (*Time)%999;        /* last 3 digits for file */
  284. if (cs.newprot) {
  285.     sprintf(filename, "dfA%03d%d.%d.%d.%d", filetime,
  286.         myipnum[0], myipnum[1], myipnum[2], myipnum[3]);
  287.     }
  288. else {
  289.     sprintf(filename, "fA%03d%d.%d.%d.%d", filetime,
  290.         myipnum[0], myipnum[1], myipnum[2], myipnum[3]);
  291.     }
  292. sprintf(prtmsg, "server filename = <%s>", filename);
  293. putln(prtmsg);
  294.  
  295. sprintf(sbuf, "\3%ld d%s\r", filesize, filename);
  296. tcpwrite(sbuf, strlen(sbuf));
  297. }
  298.  
  299. void sendctlinfo(void)
  300. {
  301. register short i;
  302. short copies;
  303.  
  304. sprintf(cmds, "H%d.%d.%d.%d\r", myipnum[0],
  305.     myipnum[1], myipnum[2], myipnum[3]);
  306. if (cs.orguser[0] != 0) sprintf(cmds+strlen(cmds), "P%s\r", cs.orguser);
  307. else sprintf(cmds+strlen(cmds), "P%s\r", ds.orguser);
  308. if (cs.hdrflag) {
  309.     if (cs.jobname[0] != 0) sprintf(cmds+strlen(cmds), "J%s\r", cs.jobname);
  310.     else sprintf(cmds+strlen(cmds), "J%s\r", ds.jobname);
  311.     if (cs.hdrclass[0] != 0) sprintf(cmds+strlen(cmds), "C%s\r", cs.hdrclass);
  312.     else sprintf(cmds+strlen(cmds), "C%s\r", ds.hdrclass);
  313.     if (cs.hdrid[0] != 0) sprintf(cmds+strlen(cmds), "L%s\r", cs.hdrid);
  314.     else sprintf(cmds+strlen(cmds), "L%s\r", ds.hdrid);
  315.     }
  316. if (cs.fmttype == 3) {
  317.     if (cs.findent > 0) sprintf(cmds+strlen(cmds), "I%d\r", cs.findent);
  318.     if (cs.fwidth > 0) sprintf(cmds+strlen(cmds), "W%d\r", cs.fwidth);
  319.     if (cs.fmttitle[0] != 0) sprintf(cmds+strlen(cmds), "T%s\r", cs.fmttitle);
  320.     }
  321. copies = cs.copycnt;
  322. if (copies <= 0) copies = 1;
  323. for (i=0; i < copies; i++) {
  324.     if (cs.fmttype == 3)
  325.         sprintf(cmds+strlen(cmds), "pd%s\r", filename);
  326.     else
  327.         sprintf(cmds+strlen(cmds), "fd%s\r", filename);
  328.     }
  329. sprintf(cmds+strlen(cmds), "Ud%s\r", filename);
  330. if (cs.vmflag) {
  331.     sprintf(cmds+strlen(cmds), "B%s %s", cs.vmuser, vmpass);
  332.     if (cs.vmform[0] != 0) sprintf(cmds+strlen(cmds), " %s", cs.vmform);
  333.     else sprintf(cmds+strlen(cmds), " %s", ds.vmform);
  334.     if (cs.vmclass[0] != 0) sprintf(cmds+strlen(cmds), " %s\r", cs.vmclass);
  335.     else sprintf(cmds+strlen(cmds), " %s\r", ds.vmclass);
  336.     }
  337. i = 0;
  338. while (prtfname[i] != 0) {
  339.     prtfname[i] &= 0x7f;
  340.     if (prtfname[i] == ' ') prtfname[i] = '_';
  341.     i++;
  342.     }
  343. sprintf(cmds+strlen(cmds), "N%s\r", prtfname);
  344. putln("Commands:");
  345. putln(cmds);
  346. sprintf(sbuf, "\2%d c%s\r", strlen(cmds), filename);
  347. tcpwrite(sbuf, strlen(sbuf));
  348. }
  349.  
  350. void sendcontrol(void)
  351. {
  352. tcpwrite(cmds, strlen(cmds)+1);
  353. }
  354.  
  355. void server_err(s, len, prtname, ctl, file)
  356. unsigned char * s;
  357. short len, prtname, ctl, file;
  358. {
  359. unsigned char * m;
  360. short i, j;
  361. unsigned char msg1[48], s1[8], s2[6];
  362. static unsigned char msg2[] = {"Description not available"};
  363. pascal Boolean (*filterProc)();
  364.  
  365. filterProc = DlgFilter;        /* for alert */
  366.                         /* prepare first message line */
  367. if (prtname) {
  368.     strcpy(s1, "Printer");
  369.     strcpy(s2, "name");
  370.     }
  371. else {
  372.     if (ctl) strcpy(s1, "Control");
  373.     else strcpy(s1, "Data");
  374.     if (file) strcpy(s2, "file");
  375.     else strcpy(s2, "info");
  376.     }
  377. sprintf(msg1, "%s %s rejected by LPD server:", s1, s2);
  378.  
  379. memset(prtmsg, 0, 128);        /* get null-terminated string */
  380. memcpy(prtmsg, s, len);
  381. m = prtmsg;
  382. if ((m[0] == 0) && (len > 1)) m++;
  383. while ((m[0] != 0) && (m[0] < 0x20)) m++;
  384. j = 0;
  385. for (i=0; i < strlen(m); i++) {
  386.     if (m[i] <= 0x20) m[i] = 0x20;
  387.     else j = i + 1;
  388.     }
  389. m[j] = 0;
  390. if (m[0] == 0) {
  391.     c2pstr(msg1);
  392.     c2pstr(msg2);
  393.     ParamText(msg1, msg2, "\p", "\p");
  394.     p2cstr(msg1);
  395.     p2cstr(msg2);
  396.     putln(msg1);
  397.     putln(msg2);
  398.     }
  399. else {
  400.     c2pstr(msg1);
  401.     c2pstr(m);
  402.     ParamText(msg1, m, "\p", "\p");
  403.     p2cstr(msg1);
  404.     p2cstr(m);
  405.     putln(msg1);
  406.     putln(m);
  407.     }
  408. StopAlert(261, (ModalFilterProcPtr)filterProc);
  409. ParamText("\p", "\p", "\p", "\p");
  410. }
  411.  
  412. void okalrt(void)
  413. {
  414. pascal Boolean (*filterProc)();
  415.  
  416. filterProc = DlgFilter;        /* for error alert */
  417. c2pstr(setmsg1);
  418. c2pstr(setmsg2);
  419. ParamText(setmsg1, setmsg2, "\p", "\p");
  420. p2cstr(setmsg1);
  421. p2cstr(setmsg2);
  422. putln(setmsg1);
  423. putln(setmsg2);
  424. NoteAlert(263, (ModalFilterProcPtr)filterProc);
  425. ParamText("\p", "\p", "\p", "\p");
  426. }
  427.